print("Hello, World!")

python hello.py

# यह एक टिप्पणी है
print("Hello, World!")

"""
यह एक बहु-पंक्ति टिप्पणी है,
जो कई पंक्तियों तक फैली हुई है।
"""

if True:
    print("यह पंक्ति इंडेंटेड है")
    print("यह पंक्ति भी इंडेंटेड है")
print("यह पंक्ति इंडेंटेड नहीं है")

name: str = "Alice"
age: int = 25

# इंटीजर
age = 25
population = 1000000

# फ्लोट
temperature = 36.5
pi = 3.14159

# कॉम्प्लेक्स
complex_num = 3 + 4j

single_quote = 'एकल कोट स्ट्रिंग'
double_quote = "दोहरा कोट स्ट्रिंग"
multiline = """यह एक
बहु-पंक्ति स्ट्रिंग है"""

text = "Python प्रोग्रामिंग"
print(len(text))        # स्ट्रिंग की लंबाई
print(text.upper())     # अपरकेस में परिवर्तन
print(text.lower())     # लोअरकेस में परिवर्तन
print(text[0])          # पहला वर्ण
print(text[2:6])        # स्ट्रिंग स्लाइसिंग

is_active = True
is_complete = False

# बूलियन ऑपरेशन्स
result1 = True and False  # False
result2 = True or False   # True
result3 = not True        # False

value = None

if value is None:
    print("मान नल है")

numbers = [1, 2, 3, 4, 5]
numbers.append(6)      # तत्व जोड़ें
numbers.insert(0, 0)   # विशिष्ट स्थिति पर डालें
numbers.remove(3)      # विशिष्ट मान हटाएँ
numbers[0] = 10        # तत्व संशोधित करें
print(numbers)         # [10, 2, 4, 5, 6]

numbers = [10, 20, 30, 40, 50]
print(numbers[1:4])    # आउटपुट: [20, 30, 40]
print(numbers[:3])     # आउटपुट: [10, 20, 30]
print(numbers[-2:])    # आउटपुट: [40, 50]

squares = [x**2 for x in range(5)]
print(squares)         # [0, 1, 4, 9, 16]

even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)    # [0, 4, 16, 36, 64]

point = (10, 20)
x, y = point  # अनपैकिंग
print(x, y)   # आउटपुट: 10 20

single_tuple = (42,)

student = {
    "name": "John",
    "age": 20,
    "major": "Computer Science"
}

# डिक्शनरी तक पहुँचना और संशोधन
print(student["name"])
student["age"] = 21
student["gpa"] = 3.8

# सुरक्षित पहुँच
print(student.get("phone", "प्रदान नहीं किया गया"))

# डिक्शनरी पर पुनरावृत्ति
for key, value in student.items():
    print(f"{key}: {value}")

# वर्ग डिक्शनरी बनाएँ
squares_dict = {x: x**2 for x in range(5)}
print(squares_dict)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# सशर्त डिक्शनरी कॉम्प्रिहेंशन
even_squares_dict = {x: x**2 for x in range(10) if x % 2 == 0}
print(even_squares_dict)  # {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

# सेट बनाना
fruits = {"apple", "banana", "orange"}
numbers = set([1, 2, 3, 3, 4, 4, 5])  # स्वचालित डुप्लिकेशन हटाना
print(numbers)  # {1, 2, 3, 4, 5}

# सेट ऑपरेशन्स
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

print(set1 | set2)  # यूनियन: {1, 2, 3, 4, 5, 6}
print(set1 & set2)  # इंटरसेक्शन: {3, 4}
print(set1 - set2)  # अंतर: {1, 2}
print(set1 ^ set2)  # सममित अंतर: {1, 2, 5, 6}

a, b = 10, 3

print(f"जोड़: {a + b}")      # 13
print(f"घटाव: {a - b}")      # 7
print(f"गुणा: {a * b}")      # 30
print(f"भाग: {a / b}")       # 3.333...
print(f"पूर्णांक भाग: {a // b}")  # 3
print(f"मॉड्यूलस: {a % b}")      # 1
print(f"घातांक: {a ** b}")       # 1000

x, y = 5, 10

print(f"बराबर: {x == y}")     # False
print(f"असमान: {x != y}")    # True
print(f"से बड़ा: {x > y}")    # False
print(f"से छोटा: {x < y}")    # True
print(f"बराबर या बड़ा: {x >= y}")  # False
print(f"बराबर या छोटा: {x <= y}")  # True

a, b = True, False

print(f"AND ऑपरेशन: {a and b}")  # False
print(f"OR ऑपरेशन: {a or b}")    # True
print(f"NOT ऑपरेशन: {not a}")    # False

list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = list1

print(f"list1 is list2: {list1 is list2}")    # False
print(f"list1 is list3: {list1 is list3}")    # True
print(f"list1 == list2: {list1 == list2}")    # True

fruits = ["apple", "banana", "orange"]

print(f"'apple' in fruits: {'apple' in fruits}")        # True
print(f"'grape' not in fruits: {'grape' not in fruits}")  # True

age = 20
if age >= 18:
    print("वयस्क")
elif age >= 13:
    print("किशोर")
else:
    print("बच्चा")

# लिस्ट पर पुनरावृत्ति
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

# लूपिंग के लिए range() का उपयोग
for i in range(5):
    print(i)  # आउटपुट: 0, 1, 2, 3, 4

count = 0
while count < 5:
    print(count)
    count += 1

for i in range(10):
    if i == 5:
        break
    if i % 2 == 0:
        continue
    print(i)  # आउटपुट: 1, 3

http_status = 200

match http_status:
    case 200 | 201:
        print("सफलता")
    case 404:
        print("नहीं मिला")
    case 500:
        print("सर्वर त्रुटि")
    case _:  # वाइल्डकार्ड, किसी अन्य मामले से मेल खाता है
        print("अज्ञात स्थिति")

# उपयोगकर्ता इनपुट प्राप्त करना
name = input("कृपया अपना नाम दर्ज करें: ")
age = int(input("कृपया अपनी आयु दर्ज करें: "))

# जानकारी आउटपुट करना
print("स्वागत है", name)
print("आप", age, "वर्ष के हैं")

user = "Alice"
items = 3
total_cost = 45.5

# स्वरूपित संदेश के लिए f-string का उपयोग
message = f"उपयोगकर्ता {user} ने {items} आइटम ${total_cost:.2f} में खरीदे।"
print(message)

# f-strings में अभिव्यक्तियाँ
print(f"2 + 3 बराबर है {2 + 3}")

width = 10
height = 5

# f-strings में अभिव्यक्तियों का उपयोग
area = f"आयत का क्षेत्रफल: {width * height}"
print(area)

# फ़ंक्शंस को कॉल करना
text = "python"
formatted = f"अपरकेस: {text.upper()}, लंबाई: {len(text)}"
print(formatted)

pi = 3.14159265359
large_number = 1234567

# संख्या स्वरूपण
print(f"Pi (2 दशमलव): {pi:.2f}")
print(f"Pi (4 दशमलव): {pi:.4f}")
print(f"बड़ा नंबर (हज़ारों में): {large_number:,}")
print(f"प्रतिशत: {0.85:.1%}")

# स्ट्रिंग संरेखण
name = "Python"
print(f"बायाँ संरेखण: '{name:<10}'")
print(f"दायाँ संरेखण: '{name:>10}'")
print(f"केंद्र संरेखण: '{name:^10}'")

from datetime import datetime

now = datetime.now()
print(f"वर्तमान समय: {now}")
print(f"स्वरूपित समय: {now:%Y-%m-%d %H:%M:%S}")
print(f"केवल दिनांक: {now:%Y-%m-%d}")

def greet(name):
    """अभिवादन फ़ंक्शन"""
    return f"हैलो, {name}!"

# फ़ंक्शन को कॉल करना
message = greet("John")
print(message)

def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

print(greet("Alice"))          # आउटपुट: Hello, Alice!
print(greet("Bob", "Hi"))     # आउटपुट: Hi, Bob!

# स्थिति आधारित परिवर्तनीय तर्क (*args)
def sum_numbers(*args):
    return sum(args)

print(sum_numbers(1, 2, 3, 4))  # आउटपुट: 10

# कीवर्ड परिवर्तनीय तर्क (**kwargs)
def print_kwargs(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_kwargs(name="Alice", age=25, city="Beijing")

def calculate_area(length: float, width: float) -> float:
    """आयत का क्षेत्रफल गणना करें"""
    return length * width

def process_user(name: str, age: int, active: bool = True) -> dict:
    """उपयोगकर्ता जानकारी प्रोसेस करें"""
    return {
        "name": name,
        "age": age,
        "active": active
    }

square = lambda x: x ** 2
print(square(5))  # आउटपुट: 25

numbers = [1, 2, 3, 4]
squares = list(map(lambda x: x ** 2, numbers))
print(squares)  # आउटपुट: [1, 4, 9, 16]

class Person:
    """Person क्लास"""
    
    def __init__(self, name, age):
        """कंस्ट्रक्टर"""
        self.name = name
        self.age = age
    
    def introduce(self):
        """परिचय विधि"""
        return f"मैं {self.name} हूँ, {self.age} वर्ष का हूँ"
    
    def have_birthday(self):
        """जन्मदिन विधि"""
        self.age += 1
        return f"{self.name} का जन्मदिन था, अब {self.age} वर्ष का है"

# ऑब्जेक्ट्स बनाना
person1 = Person("John", 25)
person2 = Person("Jane", 30)

print(person1.introduce())
print(person2.have_birthday())

class Student:
    # क्लास विशेषताएँ
    school = "Stanford University"
    student_count = 0
    
    def __init__(self, name, major):
        # इंस्टेंस विशेषताएँ
        self.name = name
        self.major = major
        Student.student_count += 1
    
    @classmethod
    def get_student_count(cls):
        """क्लास विधि"""
        return cls.student_count
    
    @staticmethod
    def is_valid_age(age):
        """स्थैतिक विधि"""
        return 0 < age < 150

# उपयोग उदाहरण
student1 = Student("John", "Computer Science")
student2 = Student("Jane", "Mathematics")

print(f"स्कूल: {Student.school}")
print(f"कुल छात्र: {Student.get_student_count()}")
print(f"मान्य आयु: {Student.is_valid_age(20)}")

class Animal:
    def __init__(self, name, species):
        self.name = name
        self.species = species
    
    def make_sound(self):
        return f"{self.name} एक ध्वनि निकालता है"
    
    def info(self):
        return f"{self.name} एक {self.species} है"

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name, "Dog")
        self.breed = breed
    
    def make_sound(self):
        return f"{self.name} भौंकता है"
    
    def fetch(self):
        return f"{self.name} गेंद लाता है"

class Cat(Animal):
    def __init__(self, name, color):
        super().__init__(name, "Cat")
        self.color = color
    
    def make_sound(self):
        return f"{self.name} म्याऊँ करता है"
    
    def climb(self):
        return f"{self.name} पेड़ पर चढ़ता है"

# इनहेरिटेंस का उपयोग
dog = Dog("Buddy", "Golden Retriever")
cat = Cat("Mimi", "Orange")

print(dog.info())
print(dog.make_sound())
print(dog.fetch())

print(cat.info())
print(cat.make_sound())
print(cat.climb())

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def __str__(self):
        """स्ट्रिंग प्रतिनिधित्व"""
        return f"Rectangle({self.width}x{self.height})"
    
    def __repr__(self):
        """आधिकारिक स्ट्रिंग प्रतिनिधित्व"""
        return f"Rectangle(width={self.width}, height={self.height})"
    
    def __eq__(self, other):
        """समानता तुलना"""
        if isinstance(other, Rectangle):
            return self.width == other.width and self.height == other.height
        return False
    
    def __lt__(self, other):
        """से कम तुलना (क्षेत्रफल के आधार पर)"""
        if isinstance(other, Rectangle):
            return self.area() < other.area()
        return NotImplemented
    
    def __add__(self, other):
        """जोड़ ऑपरेशन"""
        if isinstance(other, Rectangle):
            return Rectangle(self.width + other.width, self.height + other.height)
        return NotImplemented
    
    def area(self):
        """क्षेत्रफल गणना"""
        return self.width * self.height

# विशेष विधियों का उपयोग
rect1 = Rectangle(3, 4)
rect2 = Rectangle(5, 6)
rect3 = Rectangle(3, 4)

print(rect1)           # Rectangle(3x4)
print(repr(rect1))     # Rectangle(width=3, height=4)
print(rect1 == rect3)  # True
print(rect1 < rect2)   # True
print(rect1 + rect2)   # Rectangle(8x10)

with open("example.txt", "r") as file:
    content = file.read()
    print(content)

class DatabaseConnection:
    def __init__(self, database_name):
        self.database_name = database_name
        self.connection = None
    
    def __enter__(self):
        """संदर्भ में प्रवेश करने पर कॉल किया जाता है"""
        print(f"डेटाबेस से कनेक्ट हो रहा है: {self.database_name}")
        self.connection = f"{self.database_name} से कनेक्शन"
        return self.connection
    
    def __exit__(self, exc_type, exc_value, traceback):
        """संदर्भ से बाहर निकलने पर कॉल किया जाता है"""
        print(f"डेटाबेस कनेक्शन बंद हो रहा है: {self.database_name}")
        if exc_type:
            print(f"त्रुटि हुई: {exc_type.__name__}: {exc_value}")
        self.connection = None
        return False  # अपवादों को दबाएँ नहीं

# कस्टम संदर्भ प्रबंधक का उपयोग
with DatabaseConnection("user_database") as conn:
    print(f"कनेक्शन का उपयोग: {conn}")
    print("डेटाबेस ऑपरेशन्स निष्पादित हो रहे हैं...")

from contextlib import contextmanager
import time

@contextmanager
def timer(operation_name):
    """टाइमर संदर्भ प्रबंधक"""
    print(f"{operation_name} शुरू हो रहा है")
    start_time = time.time()
    try:
        yield
    finally:
        end_time = time.time()
        print(f"{operation_name} {end_time - start_time:.2f} सेकंड में पूरा हुआ")

# डेकोरेटर-आधारित संदर्भ प्रबंधक का उपयोग
with timer("डेटा प्रोसेसिंग"):
    # समय-गहन ऑपरेशन का अनुकरण
    time.sleep(1)
    print("डेटा प्रोसेसिंग...")

try:
    result = 10 / 0
except ZeroDivisionError:
    print("शून्य से विभाजन नहीं कर सकते!")
else:
    print("विभाजन सफल")
finally:
    print("यह हमेशा चलता है")

with open("example.txt", "r") as file:
    content = file.read()
    print(content)

with open("example.txt", "r") as file:
    for line in file:
        print(line.strip())

with open("output.txt", "w") as file:
    file.write("हैलो, Python!\n")

with open("output.txt", "a") as file:
    file.write("नई सामग्री जोड़ना।\n")

import math
print(math.sqrt(16))  # आउटपुट: 4.0

# mymodule.py
def say_hello():
    return "मॉड्यूल से हैलो!"

import mymodule
print(mymodule.say_hello())  # आउटपुट: मॉड्यूल से हैलो!

x = "वैश्विक x"

def outer_func():
    x = "संलग्न x"
    def inner_func():
        x = "स्थानीय x"
        print(x) # स्थानीय स्कोप x तक पहुँचता है
    inner_func()
    print(x) # संलग्न स्कोप x तक पहुँचता है

outer_func()
print(x) # वैश्विक स्कोप x तक पहुँचता है

x = "वैश्विक"
def modify_global():
    global x
    x = "संशोधित"
modify_global()
print(x)  # आउटपुट: संशोधित

a_variable = 10

def some_function():
    b_variable = 20
    # locals() वर्तमान स्थानीय नेमस्पेस डिक्शनरी लौटाता है
    print(f"स्थानीय: {locals()}")

print(f"वैश्विक: {globals().keys()}") # वैश्विक नेमस्पेस की कुंजियाँ प्रिंट करता है
some_function()

def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

for num in fibonacci(5):
    print(num)  # आउटपुट: 0, 1, 1, 2, 3

import threading
import time

def worker(thread_name):
    print(f"थ्रेड {thread_name} शुरू हो रहा है...")
    time.sleep(2) # समय-गहन ऑपरेशन का अनुकरण
    print(f"थ्रेड {thread_name} समाप्त हुआ।")

# थ्रेड्स बनाएँ
thread1 = threading.Thread(target=worker, args=("A",))
thread2 = threading.Thread(target=worker, args=("B",))

# थ्रेड्स शुरू करें
thread1.start()
thread2.start()

# सभी थ्रेड्स के पूरा होने की प्रतीक्षा करें
thread1.join()
thread2.join()

print("सभी थ्रेड्स पूरे हुए।")

import asyncio

async def say_hello():
    print("हैलो")
    await asyncio.sleep(1) # गैर-अवरोधक नींद, I/O का अनुकरण
    print("वर्ल्ड")

async def main():
    # एक कार्य बनाएँ और प्रतीक्षा करें
    await asyncio.create_task(say_hello())

# मुख्य कोरटीन चलाएँ
asyncio.run(main())